﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Linq.Expressions;
//using System.Text;

//namespace Auto.Tools.Standards.Extends
//{
//    /// <summary>
//    /// Expression表达式扩展操作类
//    /// 调用方法：repository.GetAll().AsExpandable().Where(predicate)
//    /// </summary>
//    public static class ExpressionExtensions
//    {
//        /// <summary>
//        /// 以特定的条件运行组合两个Expression表达式
//        /// </summary>
//        /// <typeparam name="T">表达式的主实体类型</typeparam>
//        /// <param name="original">第一个Expression表达式</param>
//        /// <param name="objectives">要组合的Expression表达式</param>
//        /// <param name="merge">组合条件运算方式</param>
//        /// <returns>组合后的表达式</returns>
//        public static Expression<T> Compose<T>(this Expression<T> original, Expression<T> objectives, Func<Expression, Expression, Expression> merge)
//        {
//            var map = original.Parameters.Select((f, i) => new { f, s = objectives.Parameters[i] }).ToDictionary(p => p.s, p => p.f);
//            var objectivesBody = ParameterRebinder.ReplaceParameters(map, objectives.Body);
//            return Expression.Lambda<T>(merge(original.Body, objectivesBody), original.Parameters);
//        }

//        /// <summary>
//        /// 以 Expression.AndAlso 组合两个Expression表达式
//        /// </summary>
//        /// <typeparam name="T">表达式的主实体类型</typeparam>
//        /// <param name="original">第一个Expression表达式</param>
//        /// <param name="objectives">要组合的Expression表达式</param>
//        /// <returns>组合后的表达式</returns>
//        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> original, Expression<Func<T, bool>> objectives)
//        {
//            return original = original.Compose(objectives, Expression.AndAlso);
//        }

//        /// <summary>
//        /// 以 Expression.OrElse 组合两个Expression表达式
//        /// </summary>
//        /// <typeparam name="T">表达式的主实体类型</typeparam>
//        /// <param name="original">第一个Expression表达式</param>
//        /// <param name="objectives">要组合的Expression表达式</param>
//        /// <returns>组合后的表达式</returns>
//        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> original, Expression<Func<T, bool>> objectives)
//        {
//            return original = original.Compose(objectives, Expression.OrElse);
//        }

//        private class ParameterRebinder : ExpressionVisitor
//        {
//            private readonly Dictionary<ParameterExpression, ParameterExpression> _map;

//            private ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
//            {
//                _map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
//            }

//            public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map,
//                Expression exp)
//            {
//                return new ParameterRebinder(map).Visit(exp);
//            }

//            protected override Expression VisitParameter(ParameterExpression node)
//            {
//                if (_map.TryGetValue(node, out ParameterExpression replacement))
//                {
//                    node = replacement;
//                }
//                return base.VisitParameter(node);
//            }
//        }
//    }
//}
